עץץץץ AVL הגדרה: עץ AVL הוא עץ חיפוש בינארי שמקיים את התנאי הבא: לכל צומת x בעץ גורם האיזון של x הוא 1,, או 1-. h(t left(x) ) - h(t right(x) ) 1 במילים אחרות: לכל צומת x בעץ, בעץ AVL שומרים עבור כל צומת x (בנוסף לשדות ששומרים בעץ חיפוש בינארי) שדה נוסף שנקרא balance(x) שמכיל את גורם האיזון של x. לדוגמה, העץ הבא הוא עץ :AVL 5 3 1 4 8 18 1 7 9 14 6 אם נוריד מהעץ הנ"ל את הצומת 9 (או את הצומת 14) הוא לא יהיה עץ AVL 35
.h=θ(log n) משפט: T עץ AVL יהי בעל n צמתים וגובה h. אזי: הוכחה נסמן ב- (h) T max את עץ ה- AVL בעל המספר הגדול ביותר של צמתים מבין כל עצי ה- AVL בגובה h. נסמן ב- ((h) n(t max את מספר הצמתים בעץ (h).t max לדוגמה, עבור h=1 העץ (1) max T נראה כך עבור =h העץ () max T נראה כך עבור 3=h העץ (3) max T נראה כך נספור את מספר הצמתים בעץ (h) T max לפי רמות: ברמה הראשונה יש צומת אחד ברמה השנייה יש צמתים ברמה השלישית יש צמתים וכן הלאה, עד הרמה האחרונה שבה יש 1-h צמתים. לכן נקבל את הנוסחה הבאה: n(t max (h)) = 1 + + + 3 +... + h-1 = h h 1 = 1 1 יהי T עץ AVL כלשהו בעל n צמתים וגובה h. מספר הצמתים ב- T קטן או שווה למספר הצמתים בעץ בעל מספר הצמתים הגדול ביותר מבין כל העצים בגובה.h ולכן נקבל: (h)) n n(t max נציב את הערך של ((h) n(t max שמצאנו בנוסחה הקודמת ונקבל: n n+ 1 h h 1 log (n+ 1) h h log(n+ 1) = θ(log n) h= Ω(log n) ולכן: ולכן הראנו ש- 36
נסמן ב- (h) T min את עץ ה- AVL בעל המספר הקטן ביותר של צמתים מבין כל עצי ה- AVL בגובה h. (במקרה הזה העץ לא בהכרח יחיד). נסמן ב- ((h) n(t min את מספר הצמתים בעץ (h) T. min לדוגמה, עבור 1=h העץ (1) min T נראה כך עבור =h העץ () min T נראה כך עבור 3=h העץ (3) min T נראה כך עבור 4=h העץ (4) min T נראה כך n(t min (h)) = n(t min (h-1)) + n(t min (h-)) + 1 עזר: טענת טענת העזר: יהי T עץ AVL בגובה h בעל מספר קטן ביותר של צמתים הוכחת מבין כל עצי ה- AVL בגובה h. לפי הגדרה, מספר הצמתים ב- T הוא ((h).n(t min נסמן ב- r את שורש העץ T. אם הגובה של תת העץ השמאלי של r שווה לגובה של תת העץ הימני של r אזי הגובה של שניהם חייב להיות 1-h (אחרת הגובה של T לא יהיה ), h ואז אפשר להוריד צומת אחת מאחד משני העצים האלה (לא חשוב מאיזה) ולקבל עץ AVL בגובה h שמספר הצמתים בו הוא אחד פחות ממספר הצמתים בעץ T, דהינו מספר הצמתים בעץ שנקבל יהיה 1-((h),n(T min סתירה. לכן הגובה של תת העץ השמאלי של r שונה מהגובה של תת העץ הימני של r. ולכן הגובה של אחד מהם (נניח השמאלי) חייב להיות 1-h והגובה של השני (נניח הימני) חייב להיות -h. מספר הצמתים בתת העץ השמאלי חייב להיות ((1-h) n(t min כי זה המספר הקטן ביותר האפשרי לעץ בגובה 1-h ואם מספר הצמתים יהיה גדול מזה, אז נקבל סתירה לכך ש T הוא עץ AVL בגובה h בעל מספר קטן ביותר של צמתים. באופן דומה, מספר הצמתים בתת העץ הימני חייב 37
להיות ((-h).n(t min לסיכום הנוסחה שלעיל נובעת מכך שמספר הצמתים בעץ T שווה למספר הצמתים בתת העץ השמאלי של r ועוד מספר הצמתים בתת העץ הימני של r ועוד אחד (עבור השורש r). מ.ש.ל מטענת העזר נקבל: n(t min (h)) = n(t min (h-1)) + n(t min (h-)) + 1 n(t min (h-)) + n(t min (h-)) + 1 n(t min (h-)) + n(t min (h-)) = n(t min (h-)) (1) n(t min (h)) n(t min (h-)) ולכן קיבלנו ש- נציב ב- (1) -h במקום h ונקבל: () n(t min (h-)) n(t min (h-4)) מ - (1) ו- () נקבל: (3) n(t min (h)) n(t min (h-4)) באופן כללי נקבל: n(t min (h)) i n(t min (h-i)) i= h 1 נחפש i שמקיים = 1 h-i ונקבל מאחר - i חייב להיות מספר שלם נוכל להציב את ה- i הזה רק עבור h אי זוגי. n(t h 1 h 1 min (h)) n(tmin (1)) = n(t h i= ולכן במקרה ש- h אי זוגי נקבל: במקרה ש- h זוגי נחפש i שמקיים = h-i ונקבל ולכן במקרה ש- h זוגי נקבל: h h h h 1 min (h)) n(tmin ()) = = 38
לסיכום, בשני המקרים (h זוגי ו- h אי זוגי) קיבלנו: n(t h 1 min (h)) יהי T עץ AVL כלשהו בעל n צמתים וגובה h. מספר הצמתים ב- T גדול או שווה למספר הצמתים בעץ בעל מספר הצמתים הקטן ביותר מבין כל העצים בגובה.h ולכן נקבל: (h)) n n(t min נציב את אי השוויון שמצאנו עבור ((h) n(t min בנוסחה הקודמת ונקבל: n n(t h 1 min (h)) n h 1 h 1 log n h log n+ 1= θ(log n) ולכן: h= Ο(log n) ולכן הראנו ש- לסיכום, הראנו ש- מ.שששש.לללל h= θ(log n) 39
לאלגוריתם ההוספה לעץ AVL דוגמאות דוגמה עם גלגול LL הוספה : 1 להלן עץ AVL שבו מעל כל צומת רשום גורם האיזון שלה. +1 1 +1-1 7 5 8 5 4 6 נראה איך מוסיפים צומת לעץ הנ"ל. בשלב ראשון מוספים את לעץ כמו שמוסיפים לעץ חיפוש בינארי והתוצאה היא: 4
+1 1 +1-1 7 5 8 5 4 6 בשלב הבא, מתחילים לטפס מהצומת שהוספנו כלפי מעלה ומעדכנים גורמי איזון. אם הגענו לצומת שגורם האיזון שלה היה משנים אותו ל 1 או ל 1- תלוי מאיזה כוון הגענו, וממשיכים לטפס למעלה. בדוגמה שלנו נשנה את גורמי האיזון של הצמתים, 4 ו- 5 להיות 1+ ונקבל את העץ הבא: 41
+1 1 +1-1 7 +1 5 8 5 +1 4 6 כשנמשיך לטפס, נגיע לצומת 7 שגורם האיזון שלה הופך להיות +. נקרא לצומת הזאת "צומת בעיתית" (כי אסור לנו לשנות את גורם האיזון שלה שלה ל- +). במקום לשנות את גורם האיזון של הצומת הבעייתית, נבצע "גלגול" סביב הצומת הבעייתית. לפני שנבצע את הגלגול עלינו לקבוע את "סוג הגלגול". כדי לקבוע את סוג הגלגול נלך שני צעדים מהצומת הבעייתית לעבר הצומת שהוספנו. אם הלכנו פעמיים שמאלה (כמו במקרה הנ"ל) אז הגלגול הוא מסוג LL אם הלכנו פעמים ימינה אז הגלגול הוא מסוג RR אם הלכנו שמאלה ואחר כך ימינה אז הגלגול הוא מסוג LR אם הלכנו ימינה ואחר כך שמאלה אז הגלגול הוא מסוג RL בדוגמה הנ"ל נבצע גלגול מסוג LL סביב צומת 7. הגלגול מתבצע על תת העץ ששורשו 7, ולכן נסתכל עכשיו על תת העץ הזה ונראה איך מתבצע הגלגול. 4
L 7 L 5 8 4 6 בגלגול LL מסובבים ימינה סביב הצומת הבעייתית. זאת אומרת 5 הופכת להיות השורש ו- 7 הופכת להיות הבן הימני של 5. בנוסף שומרים על כל הקשרים שהיו מקודם, חוץ מהקשר החדש שמתבטא בציור למעלה על ידי הקו המקווקו, שמחבר בין 7 ל -6. לכן לאחר הגלגול התוצאה היא: 5 4 7 6 8 כעת נחליף בעץ המקורי את תת העץ ששורשו 7, בתת העץ שהתקבל לאחר הגלגול (ששורשו הוא 5) ונקבל את העץ הבא: 43
1 5 4 7 5 6 8 מאחר ולאחר הגלגול הגובה של תת העץ השמאלי של 1 (כולל התוספת של הצומת ) שווה לגובה של תת העץ השמאלי של 1 לפני שהוספנו את צומת, גורם האיזון של 1 הוא נכון (נשאר כפי שהיה בעץ המקורי), ולכן אפשר לעצור את האלגוריתם (בלי להמשיך לטפס ל- 1) ולסיים את הוספת לעץ. 44
דוגמה עם גלגול RR הוספה : להלן עץ AVL שבו מעל כל צומת רשום גורם האיזון שלה. -1 1-1 7 5 נראה איך מוסיפים צומת 3 לעץ הנ"ל. כמו בדוגמה הקודמת בשלב ראשון מוספים את 3 לעץ כמו שמוסיפים לעץ חיפוש בינארי ובשלב השני מטפסים מהצומת שהוספנו למעלה ומעדכנים גורמי איזון, עד שמגיעים ל"צומת בעיתית". והתוצאה היא: -1 1-1 7 R -1 5 R 3 כאשר הצומת היא "צומת בעיתית". כמו קודם, כדי לקבוע את סוג הגלגול נלך שני צעדים מהצומת הביתית לעבר הצומת שהוספנו. מאחר והלכנו פעמים ימינה סוג הגלגול הוא.RR בגלגול RR מסובבים שמאלה סביב הצומת הבעייתית. זאת אומרת 5 הופכת להיות השורש ו- הופכת להיות הבן השמאלי של 5. בנוסף שומרים על כל הקשרים שהיו מקודם, חוץ מהקשר החדש בין לבן השמאלי של 5 (אם היה לו בן כזה). מאחר ובדוגמה הזאת ל- 5 אין בן שמאלי, זה מקרה מנוון שאין בו קשר חדש. לכן לאחר הגלגול התוצאה הסופית היא: 45
-1 1 7 5 3 דוגמה עם גלגול LR הוספה : 3 להלן עץ AVL שבו מעל כל צומת רשום גורם האיזון שלה. +1 1-1 5 3 4 8 5 7 9 נראה איך מוסיפים צומת 6 לעץ הנ"ל. כמו בדוגמאות הקודמת בשלב ראשון מוספים את 6 לעץ כמו שמוסיפים לעץ חיפוש בינארי ובשלב השני מטפסים מהצומת שהוספנו למעלה ומעדכנים גורמי איזון, עד שמגיעים ל"צומת בעיתית". והתוצאה היא: 46
+1 1-1 L -1 5 3 R -1 4 8 5 +1 7 9 6 כמו קודם, כדי לקבוע את סוג הגלגול נלך שני צעדים מהצומת הביתית לעבר הצומת שהוספנו. מאחר והלכנו שמאלה ואחר כך ימינה סוג הגלגול הוא.LR גלגול LR מורכב משני שלבים: בשלב ראשון מבצעים גלגול מסוג RR (דהינו מסובבים שמאלה) סביב הבן השמאלי של הצומת הבעייתית. בשלב שני (על התוצאה של השלב הקודם) מבצעים גלגול מסוג LL (דהינו מסובבים ימינה) סביב הצומת הבעייתית. לאחר השלב הראשון, דהינו גלגול RR סביב צומת 5 העץ נראה כך: 47
+1 1-1 8 5 5 9 3 7 6 לאחר השלב השני, דהינו גלגול LL סביב צומת 1 העץ נראה כך: 8-1 5 1 3 7 9 5 6 ובכך מסתימת הוספת 6 לעץ. 48
דוגמה עם גלגול RL הוספה : 4 להלן עץ.AVL 8 1 נראה איך מוסיפים 9 לעץ הזה. לאחר הוספת 9 וביצוע השלב הראשון והשני עד שמגיעים לצומת הבעייתית מתקבל העץ הבא: 8 R L 1 9 כמו קודם, כדי לקבוע את סוג הגלגול נלך שני צעדים מהצומת הביתית לעבר הצומת שהוספנו. מאחר והלכנו ימינה ואחר כך שמאלה סוג הגלגול הוא.RL גלגול LR מורכב משני שלבים: בשלב ראשון מבצעים גלגול מסוגLL (דהינו מסובבים ימינה) סביב הבן הימני של הצומת הבעייתית. בשלב שני (על התוצאה של השלב הקודם) מבצעים גלגול מסוג RR (דהינו מסובבים שמאלה) סביב הצומת הבעייתית. לאחר השלב הראשון, דהינו גלגול LL סביב צומת 1 העץ נראה כך: 49
8 9 1 לאחר השלב השני, דהינו גלגול RR סביב צומת 8 העץ נראה כך: 9 8 1 וזה העץ הסופי לאחר הוספת 9 לעץ המקורי. 5
לאלגוריתם ההוצאה מעץ AVL דוגמאות דוגמה עם גלגול LL הוצאה : 1 להלן עץ AVL שבו מעל כל צומת רשום גורם האיזון שלה. +1 1 +1-1 7 5 8 5 4 6 נראה איך מוציאים צומת 8 מהעץ הנ"ל. בשלב ראשון מוציאים את 8 מהעץ כמו שמוציאים מעץ חיפוש בינארי והתוצאה היא: +1 1 +1-1 7 5 5 4 6 בשלב הבא, מתחילים לטפס מהאבא של הצומת שהוצאנו כלפי מעלה ומעדכנים גורמי איזון. אם הגענו לצומת שגורם האיזון שלה היה משנים אותו ל 1 או ל 1- תלוי מאיזה כוון הגענו, וממשיכים לטפס למעלה. בדוגמה שלנו אנחנו מגיעים לצומת 7 שגורם האיזון שלה אחרי ההוצאה הופך להיות 51
+. נקרא לה "צומת בעיתית" ונבצע סביבה גלגול. סוג הגלגול יקבע באופן הבא: אם הצומת שהוצאנו נמצא בתת העץ השמאלי של הצומת הבעייתית, אזי נלך שני צעדים ראשונים לכוון העלה העמוק ביותר בתת העץ הימני של הצומת הבעייתית. אם הצומת שהוצאנו נמצא בתת העץ הימני של הצומת הבעייתית, אזי נלך שני צעדים ראשונים לכוון העלה העמוק ביותר בתת העץ השמאלי של הצומת הבעייתית. בשני המקרים: אם הלכנו פעמיים שמאלה נבצע גלגול LL אם הלכנו פעמים ימינה נבצע גלגול RR אם הלכנו שמאלה ואחר כך ימינה נבצע גלגול LR אם הלכנו ימינה ואחר כך שמאלה נבצע גלגול RL אם אפשר לבחור גם בגלגול LL וגם בגלגול,LR נבחר בגלגול.LL אם אפשר לבחור גם בגלגול RR וגם בגלגול RL נבחר בגלגול.RR בדוגמה שלנו אפשר לבחור גם בגלגול LL וגם בגלגול LR ולכן נבחר בגלגול LL ונבצע אותו סביב הצומת הבעייתית : 7 +1 1 +1-1 7 4 L L 5 5 6 הגלגולים מתבצעים בדיוק באותו אופן כמו הגלגולים שתוארו באלגוריתם ההוספה. ולכן לאחר ביצוע גלגול LL סביב הצומת 7 התוצאה תהיה: 5
+1 1-1 5 4 7 5 6 באלגוריתם ההוספה לאחר ביצוע גלגול אחד האלגוריתם עוצר. באלגוריתם ההוצאה לאחר ביצוע גלגול בודקים: אם גובה תת העץ מתחת הצומת הבעייתית לפני ההוצאה שווה לגובה תת העץ שנוצר לאחר ביצוע הגלגול אזי האלגוריתם עוצר. אם גובה תת העץ מתחת הצומת הבעייתית לפני ההוצאה קטן מגובה תת העץ שנוצר לאחר ביצוע הגלגול אזי האלגוריתם ממשיך לטפס למעלה לעדכן גורמי איזון (ולבצע גלגולים אם צריך). לכן, באלגוריתם ההוצאה יתכן ויקרו הרבה גלגולים (להבדיל מאלגוריתם ההוספה שבו מתבצע לכל היותר גלגול אחד). בדוגמה שלנו מאחר וגובה תת העץ ששורשו 7 לפני ההוצאה שווה לגובה תת העץ שנוצר אחרי הגלגול ששורשו 5, האלגוריתם עוצר. 53
דוגמה עם גלגול LR הוצאה : להלן עץ AVL שבו מעל כל צומת רשום גורם האיזון שלה. +1 1-1 -1 7-1 8 9 5 נראה איך מוציאים את צומת 5 מהעץ הנ"ל. כמו בדוגמה הקודמת בשלב ראשון מוציאים את 5 כמו שמוציאים מעץ חיפוש בינארי ובשלב השני מטפסים מהאבא של הצומת שהוצאנו למעלה ומעדכנים גורמי איזון, עד שמגיעים ל"צומת בעיתית". והתוצאה היא: +1 1-1 L -1 7 R -1 8 9 כאשר הצומת 1 היא "צומת בעיתית". כמו קודם, כדי לקבוע את סוג הגלגול 54
נלך שני צעדים מהצומת הביתית לעבר העלה העמוק ביותר בתת העץ המנוגד לזה שממנו הוצאנו את הצומת. בדוגמה שלנו נלך שני צעדים החל מ- 1 לכוון 9 ומאחר והלכנו שמאלה ואחר כך ימינה נבצע גלגול מסוג LR סביב צומת 1. גלגול LR הוא אותו גלגול כפי שתואר באלגוריתם ההוספה. לאחר השלב הראשון של הגלגול LR (גלגול RR סביב צומת 7) התוצאה היא: 1 8 7 9 לאחר השלב השני של הגלגול LR (גלגול LL סביב צומת 1) התוצאה היא: 8 7 1 9 במקרה זה גובה תת העץ לאחר ביצוע הגלגול קטן ב- 1, ולכן אם צומת 8 לא הייתה השורש האלגוריתם היה ממשיך ומטפס למעלה. מאחר וצומת 8 היא השורש האלגוריתם עוצר. 55
דוגמה גלגול LL ולאחריו עם גלגול RL הוצאה : 3 להלן עץ.AVL נראה איך מוציאים את צומת 17 מעץ זה. 16 1 7 13 5 17 5 9 14 כמו בדוגמאות הקודמת בשלב ראשון מוציאים את 17 כמו שמוציאים מעץ חיפוש בינארי. והתוצאה היא: 16 1 R 7 13 5 5 9 14 L בשלב שני, מזהים שהצומת היא צומת בעיתית, ושסוג הגלגול הנדרש הוא.RL לאחר ביצוע הגלגול RL התוצאה היא: 56
L 16 L 1 7 13 5 5 9 14 מאחר וגובה תת העץ לאחר הגלגול קטן ב- 1 ממשיכים לטפס כלפי מעלה, מגיעים לצומת 16, מזהים שהיא צומת בעיתית ושסוג הגלגול הנדרש סביבה הוא.LL לאחר ביצוע הגלגול התוצאה היא: L 1 7 16 5 9 13 5 14 מאחר והגענו לשורש האלגוריתם עוצר. 57
אלגוריתם הוספת איבר לעץ.AVL Insert(T,w).x=w בצע w קרא לפונקציה Insert(T,w) של עץ חיפוש בינארי להוםפת לעץ. (1 y=parent(x) ( אם y=null סיים. (3 אם = Balance(y) (ז"א גורם האיזון בצומת y בעץ לפני הוספת w היה ) בצע: (4.1 אם x בן ימני של y בצע: -1 = Balance(y) x=y ; וחזור לצעד. (4. אם x בן שמאלי של y בצע: +1 = Balance(y) x=y ; וחזור לצעד. (4 וסיים. (5 אם +1 = Balance(y) בצע: 5.1) אם x בן ימני של y בצע Balance(y)= הציור המתאים למצב זה: +1 y h+1 x h w 58
5.) אם x בן שמאלי של y בצע : 5..1) אם w נמצא בתת העץ השמאלי של x בצע גלגול מסוג LL בצומת y וסיים. הציור המתאים למצב זה: +1 y L a L x b c w אם w נמצא בתת העץ הימני של x בצע גלגול מסוג LR בצומת y וסיים. הציור המתאים למצב זה: +1 y (5.. L a x R b c w וסיים. (6 אם -1 = Balance(y) בצע: 6.1) אם x בן שמאלי של y בצע Balance(y)= הציור המתאים למצב זה: -1 y h x h+1 w 59
6.) אם x בן ימני של y בצע : 6..1) אם w נמצא בתת העץ הימני של x בצע גלגול מסוג RR בצומת y וסיים. הציור המתאים למצב זה: -1 y R a b x R c w אם w נמצא בתת העץ השמאלי של x בצע גלגול מסוג RL בצומת y וסיים. הציור המתאים למצב זה: -1 y (6.. R a b L x c w 6
אלגוריתם הוצאת איבר מעץ.AVL Delete(T,z) מהעץ. קרא לפונקציה Delete(T,z) של עץ חיפוש בינארי להוצאת z יהי w הצומת שהוצא מהעץ. (אם ל- z היה לכל היותר בן אחד אזי w=z אחרת ) right(z).( w=minimum(t בצע:.x=w (1 y=parent(x) ( אם y=null סיים. (3 אם = Balance(y) (ז"א גורם האיזון בצומת y בעץ לפני הוצאת w היה ) 4.1) אם x בן ימני של y בצע: 1+ = Balance(y) וסיים. 4.) אם x בן שמאלי של y בצע: 1- = Balance(y) וסיים. בצע: (4 וחזור לצעד. (5 אם +1 = Balance(y) בצע: (5.1 אם x בן שמאלי של y בצע Balance(y)= x=y ; הציור המתאים למצב זה: +1 y h+1 x h w 61
(5. אם x בן ימני של y בצע : יהיו a=left(y) c=right(a) ; b=left(a) ; (5..1 אם( H(T b ) h(t c בצע גלגול מסוג LL בצומת.y אם לאחר הגלגול גובה העץ T y לא השתנה סיים. אחרת בצע: x=y וחזור לצעד. +1 y הציור המתאים למצב זה: L b L a c x w אם( H(T b ) < h(t c בצע גלגול מסוג LR בצומת.y בצע: x=y וחזור לצעד. (5.. +1 y הציור המתאים למצב זה: L b a R c x w וחזור לצעד. (6 אם -1 = Balance(y) בצע: (6.1 אם x בן ימני של y בצע Balance(y)= x=y ; הציור המתאים למצב זה: -1 y h x h+1 w 6
(6. אם x בן שמאלי של y בצע : יהיו a=right(y) c=right(a) ; b=left(a) ; (6..1 אם( H(T c ) h(t b בצע גלגול מסוג RR בצומת.y אם לאחר הגלגול גובה העץ T y לא השתנה סיים. אחרת בצע: x=y וחזור לצעד. -1 y הציור המתאים למצב זה: R x w b a R c אם( H(T c ) < h(t b בצע גלגול מסוג RL בצומת.y בצע: x=y וחזור לצעד. (6.. -1 y הציור המתאים למצב זה: R x w b L a c 63
גלגול LL בהוספה להלן המצב המתואר בצעד 5..1 לפני ביצוע הגלגול מסוג :LL +1 y L a L x b c w נסמן ב- h את הגובה של תת העץ אזי נקבל שלפני ביצוע הגלגול (וללא הוספת w): לאחר ביצוע גלגול LL בצומת y נקבל:.h(T a )=h דהינו,w לפני שהוספנו את T a h(t b )=h, h(t c )=h, h(t y )=h+ x a L y w b c לאחר ביצוע הגלגול הגובה +h=( h(t x (כולל את הצומת w). מכיוון שגובה תת העץ שסביבו נעשה הגלגול נשאר כמו שהיה לפני הוספת w, אלגוריתם ההוספה עוצר. 64
גלגול RR בהוספה להלן המצב המתואר בצעד 6..1 לפני ביצוע הגלגול מסוג :RR -1 y R a b x R c w לאחר ביצוע גלגול RR בצומת y נקבל: x y c a b w מכיוון שגובה תת העץ שסביבו נעשה הגלגול נשאר כמו שהיה לפני הוספת w, אלגוריתם ההוספה עוצר. 65
גלגול LR בהוספה להלן המצב המתואר בצעד 5.. לפני ביצוע הגלגול מסוג :LR +1 y L a x R b c נוסיף לציור את שני הבנים של b ונקרא להם d ו-. e הצומת w יכול להיות צאצא של d או של e. לצורך ההדגמה נניח ש- w הוא צאצא של d ונקבל את הציור הבא: +1 y w L a x R b c d e w גלגול LR סביב צומת y מתבצע בשני שלבים: 1) גלגול RR סביב צומת x ) גלגול LL סביב צומת y לאחר גלגול LR סביב צומת y יתקבל הציור הבא: b x y a d e c w מכיוון שגובה תת העץ שסביבו נעשה הגלגול נשאר כמו שהיה לפני הוספת w, אלגוריתם ההוספה עוצר. 66
גלגול RL בהוספה להלן המצב המתואר בצעד 6.. לפני ביצוע הגלגול מסוג :RL -1 y R a b L x c w נוסיף לציור את שני הבנים של b ונקרא להם d ו-. e הצומת w יכול להיות צאצא של d או של e. לצורך ההדגמה נניח ש- w הוא צאצא של d ונקבל את הציור הבא: -1 y R a b L x c d e e w סביב צומת y מתבצע בשני שלבים: 1) גלגול LL סביב צומת x ) גלגול RR סביב צומת y גלגול RL לאחר גלגול RL סביב צומת y יתקבל הציור הבא: b y x a d e c w מכיוון שגובה תת העץ שסביבו נעשה הגלגול נשאר כמו שהיה לפני הוספת w, אלגוריתם ההוספה עוצר. 67
גלגול LL בהוצאה להלן המצב המתואר בצעד 5..1 לפני ביצוע הגלגול מסוג :LL +1 y L או +1 L b a c x w לאחר ביצוע גלגול LL בצומת y נקבל: a b L y c x w מחישובי הגבהים נקבל שקימות שתי אפשרויות: 1) אם בצומת a (לפני ההוצאה) גורם האיזון היה אזי מכיוון שגובה תת העץ שסביבו נעשה הגלגול נשאר כמו שהיה לפני הוצאת w, אלגוריתם ההוצאה עוצר. ) אם בצומת a (לפני ההוצאה) גורם האיזון היה 1+ אזי מכיוון שגובה תת העץ שסביבו נעשה הגלגול קטן ב- 1, אלגוריתם ההוצאה ממשיך. 68
גלגול RR בהוספה להלן המצב המתואר בצעד 6..1 לפני ביצוע הגלגול מסוג :RR -1 y R x w או -1 b a R c לאחר ביצוע גלגול RR בצומת y נקבל: a y c x b w מחישובי הגבהים נקבל שקימות שתי אפשרויות: 1) אם בצומת a (לפני ההוצאה) גורם האיזון היה אזי מכיוון שגובה תת העץ שסביבו נעשה הגלגול נשאר כמו שהיה לפני הוצאת w, אלגוריתם ההוצאה עוצר. ) אם בצומת a (לפני ההוצאה) גורם האיזון היה 1- אזי מכיוון שגובה תת העץ שסביבו נעשה הגלגול קטן ב- 1, אלגוריתם ההוצאה ממשיך. 69
גלגול LR בהוצאה להלן המצב המתואר בצעד 5.. לפני ביצוע הגלגול מסוג :LR +1 y L -1 a R x b c w נוסיף לציור את שני הבנים של c ונקרא להם d ו- e. +1 y נקבל את הציור הבא: L -1 a R x b c w d e לאחר גלגול LR סביב צומת y יתקבל הציור הבא: c a y b d e x w מחישובי הגבהים נקבל שגובה תת העץ שסביבו נעשה הגלגול קטן ב- 1 ולכן אלגוריתם ההוצאה ממשיך. 7
גלגול RL בהוצאה להלן המצב המתואר בצעד 6.. לפני ביצוע הגלגול מסוג :RL -1 y R x L a +1 w b c נוסיף לציור את שני הבנים של b ונקרא להם d ו- e. נקבל את הציור הבא: -1 y R x L a +1 w b c d e לאחר גלגול RL סביב צומת y יתקבל הציור הבא: b y a x d e c w מחישובי הגבהים נקבל שגובה תת העץ שסביבו נעשה הגלגול קטן ב- 1 ולכן אלגוריתם ההוצאה ממשיך. 71
עץץץץ -3 להלן דוגמה לעץ -3: 7 16 5 7 8 1 16 18 19 5 7 8 1 16 18 19-3 עץ תכונות לכל צומת פנימית או 3 בנים. יוצא מן הכלל: אם בעץ -3 ישנו איבר אחד בלבד אז הוא נראה כך (ורק במקרה זה מותר שלשורש יהיה בן אחד): (1 הצמתים הפנימיים הם צמתי דמה, אין להם שדות key ו-.info האיברים של מבנה הנתונים נמצאים בעלים ולהם יש שדות key ו-.info העלים מסודרים משמאל לימין בסדר עולה לפי מפתחות האיברים אותם הם מיצגים. ( (3 כל העלים באותה רמה (ז"א כולם באותו מרחק מהשורש). (4 7
לכל עלה x בעץ ישנם את השדות הבאים: parent(x), first(x), second(x), third(x),key(x),info(x) לכל צומת פנימית x בעץ ישנם את השדות הבאים: parent(x), first(x), second(x), third(x),s1(x),s(x),s3(x) (5 (6 כאשר: first(x) מציין את המפתח הקטן ביותר בתת העץ ששורשו - s1(x) דהינו בתת העץ first(x) T second(x) מציין את המפתח הקטן ביותר בתת העץ ששורשו - s(x) דהינו בתת העץ T second(x) third(x) מציין את המפתח הקטן ביותר בתת העץ ששורשו - s3(x) דהינו בתת העץ T third(x) 73
.h=θ(log n) משפט: T עץ -3 יהי בעל n צמתים וגובה h. אזי: הוכחה נסמן ב- (h) T max את עץ ה- -3 בעל המספר הגדול ביותר של צמתים מבין כל עצי ה- AVL בגובה h. נסמן ב- ((h) n(t max את מספר הצמתים בעץ (h).t max לדוגמה, עבור h=1 העץ (1) max T נראה כך עבור =h העץ () max T נראה כך עבור 3=h העץ (3) max T נראה כך נספור את מספר הצמתים בעץ (h) T max לפי רמות: ברמה הראשונה יש צומת אחד ברמה השנייה יש 3 צמתים ברמה השלישית יש 3 צמתים וכן הלאה, עד הרמה האחרונה שבה יש 1-h 3 צמתים. לכן נקבל את הנוסחה הבאה: n(t max (h)) = 1 + 3 + 3 + 3 3 +... + 3 h-1 = 3 1 3 1 = 3 1 יהי T עץ -3 כלשהו בעל n צמתים וגובה h. מספר הצמתים ב- T קטן או שווה למספר הצמתים בעץ בעל מספר הצמתים הגדול ביותר מבין כל העצים בגובה.h ולכן נקבל: (h)) n n(t max נציב את הערך של ((h) n(t max שמצאנו בנוסחה הקודמת ונקבל: h h h 3 1 n n+ 1 h 3 ולכן: (n log 3 + 1) h h log3(n+ 1) = θ(log n) h= Ω(log n) ולכן הראנו ש- 74
נסמן ב- (h) T min את עץ ה- -3 בעל המספר הקטן ביותר של צמתים מבין כל עצי ה- AVL בגובה h. נסמן ב- ((h) n(t min את מספר הצמתים בעץ (h).t min לדוגמה, עבור h=1 העץ (1) min T נראה כך עבור =h העץ () min T נראה כך עבור 3=h העץ (3) min T נראה כך נספור את מספר הצמתים בעץ (h) T min לפי רמות: ברמה הראשונה יש צומת אחד ברמה השנייה יש צמתים ברמה השלישית יש צמתים וכן הלאה, עד הרמה האחרונה שבה יש 1-h צמתים. לכן נקבל את הנוסחה הבאה: n(t min (h)) = 1 + + + 3 +... + h-1 = h h 1 = 1 1 יהי T עץ -3 כלשהו בעל n צמתים וגובה h. מספר הצמתים ב- T גדול או שווה למספר הצמתים בעץ בעל מספר הצמתים הקטן ביותר מבין כל העצים בגובה.h ולכן נקבל: (h)) n n(t min נציב את הערך של ((h) n(t min שמצאנו בנוסחה הקודמת ונקבל: n n+ 1 h (n log 1 h + 1) h h log(n+ 1) = θ(log n) h= Ο(log n) ולכן: ולכן הראנו ש- לסיכום, הראנו ש- מ.שששש.לללל h= θ(log n) 75
-3 לאלגוריתם ההוספה לעץ דוגמאות : 1 דוגמה להלן עץ -3. נראה איך מוסיפים 4 לעץ הזה. 7 16 5 7 8 1 16 18 19 5 7 8 1 16 18 19 בעזרת צמתי הדמה נגיע לצומת הדמה שמתחתיו נרצה להוסיף את 4. במקרה שלנו, נגיע לצומת הדמה: 5 מאחר ולצומת הדמה הזה יש רק בנים נוסיף לו את 4 במקום המתאים, נעדכן מפתחות ונסים. העץ שיתקבל יראה כך: 7 16 4 5 7 8 1 16 18 19 4 5 7 8 1 16 18 19 76
: דוגמה להלן עץ -3. נראה איך מוסיפים 11 לעץ הזה. 7 16 5 7 8 1 16 18 19 5 7 8 1 16 18 19 כמו בדוגמה הקודמת בעזרת צמתי הדמה נגיע לצומת הדמה שמתחתיו נרצה להוסיף את 11. במקרה שלנו נגיע לצומת הדמה: 7 8 1 מאחר ולצומת הזה יש כבר 3 בנים לא נוכל להוסיף לה את צומת 11. נוסיף לה את 11 כבן נוסף באופן זמני, כך שיהיו לה 4 בנים : 7,8,11,1 ואז נעביר את הבנים הימניים שלה לצומת דמה חדשה. לאחר התהליך הזה העץ יראה כך: 7 16 5 7 8 11 1 16 18 19 5 167 8 16 11 16 1 16 16 18 19 11 1 עכשיו נחזור על התהליך כאשר אנחנו מוסיפים את צומת הדמה כבן נוסף של צומת הדמה: 7 16 11 מאחר ולצומת יש כבר 3 בנים נוסיף לה את 1 7 16 באופן זמני כבן נוסף כך שיהיו לה 4 בנים, ואז נעביר את הבנים הימניים שלה לצומת חדשה. מאחר הגענו לשורש, זה מקרה מיוחד בו ניצור שורש חדש לעץ. לאחר התהליך הזה העץ יראה כך: 77
11 7 11 16 5 7 8 11 1 16 18 19 5 167 8 16 11 16 1 16 16 18 19 78
-3 לאלגוריתם ההוצאה מעץ דוגמאות : 1 דוגמה להלן עץ -3. נראה איך מוציאים את 1 מהעץ הזה. 11 7 11 16 5 7 8 11 1 16 18 19 5 167 8 16 11 16 1 16 16 18 19 מאחר ולצומת 11 יש רק בנים לא נוכל להוציא את 1 1 11 1 מהצומת ולהשאיר אותה עם בן אחד. במקרה זה מאחר ולצומת יש אח עם בנים נוציא ממנה את 1 ונשאיל בן אחד מהאח שלה, ונסיים. לכן, לאחר הוצאת 1 מהעץ הנ"ל יתקבל העץ הבא: 11 7 11 18 5 7 8 11 16 18 19 5 167 8 16 11 16 16 18 19 79
1: שימו לב שבאלגוריתם ההוצאה מותר להשאיל בן מאח צמוד (מימין הערה ומשמאל) אבל אסור להשאיל בן מבן דוד או מאח שאינו צמוד. (בדוגמה הנ"ל 19 הוא אח של 16 שאינו צמוד לו). : שימו לב שבאלגוריתם ההוספה אסור להשאיל בנים בכלל (גם לא הערה מאח צמוד). : דוגמה להלן עץ -3. נראה איך מוציאים את 8 מהעץ הזה. 11 7 11 16 5 7 8 11 1 16 18 19 5 167 8 16 11 16 1 16 16 18 19 מאחר ולצומת 7 יש רק בנים לא נוכל להוציא את 8 8 5 מהצומת ולהשאיר אותה עם בן אחד. מאחר ולצומת זו אין אח צמוד עם 3 בנים לא נוכל להשאיל מאח שלה בן כפי שעשינו בדוגמה הקודמת. במקרה זה נוציא את 8 מהעץ, נעביר את האח של 8 (במקרה זה את 7) להיות בן נוסף של. לאחר התהליך הזה העץ יראה כך: 8
11 7 11 16 7 5 7 8 11 1 16 18 19 5 167 16 11 16 1 16 16 18 19 כעת מתחת הצומת 7 8 אין בנים, ונחזור על התהליך להוציא את הצומת 8 7 מאביה, דהינו מהצומת: 7 כמו במקרה הקודם, מאחר ואי אפשר להשאיל בן מאח צמוד, נעביר את הבן. לאחר התהליך הזה העץ של להיות בן נוסף של 11 16 7 יראה כך: 11 7 11 16 5 7 11 1 16 18 19 5 167 16 11 16 1 16 16 18 19 81
עכשיו נמשיך להוציא את הצומת מאביה. מאחר ואביה הוא 7 שורש העץ ויש לו רק בן אחד, זה מקרה מיוחד, שבו אנחנו הופכים את האח שלה להיות שורש העץ ומסיימים. לכן, העץ הסופי שמתקבל הוא: 11 16 5 7 11 1 16 18 19 5 167 16 11 16 1 16 16 18 19 8
ל( אלגוריתם הוספת איבר לעץ -3. Insert(T,x) אם העץ ריק (ז"א אם (root(t)=null צור צומת דמה y, את x להיות הבן הראשון של, y עדכן root(t)=y וסיים. הוסף (1 אם בעץ ישנו איבר אחד בלבד (שאינו צומת דמה). x להיות אח של איבר זה וסיים. הוסף את ( בעזרת המפתחות של צמתי הדמה, מצא את צומת הדמה y שמתחתיו יש להוסיף את x. (צומת הדמה y נמצא רמה אחת מעל לרמת העלים). (3 יש שני בנים: הוסף את x כבן נוסף של y עדכן מפתחות צמתי הדמה וסיים. (במקום 4) אם ל- y המתאים), הוסף (באופן זמני בלבד) את - y יש כרגע 4 בנים). x כבן נוסף של y במקום המתאים (5 אם y אינו שורש העץ ) ז"א אם (root(t) y צור צומת דמה חדשה 'y העבר שני בנים מ- y ל- 'y, עדכן מפתחות צמתי הדמה, בצע y=parent(y) x=y', וחזור ל- 4. (6 7) אם y הוא שורש העץ (ז"א אם (root(t)=y צור צומת דמה חדשה 'y העבר שני בנים מ- y ל- 'y, עדכן מפתחות צמתי הדמה, צור שורש חדש לעץ (z z הוא צומת דמה), חבר את y ו- 'y כבנים של, z עדכן מפתחות צומת הדמה z וסיים. 83
אלגוריתם הוצאת איבר מעץ -3. Delete(T,x) אם בעץ ישנו איבר אחד בלבד (שאינו צומת דמה), איבר זה חייב להיות x. בצע root(t)=null וסיים. אם בעץ ישנם שני איברים בלבד (שאינם צומתי דמה), אחד מהם חייב להיות x והשני z חייב להיות אח של x. נסמן ב- y את האבא של x ו- z. העבר את z להיות הבן היחיד (והראשון) של y וסיים. y=parent(x) אם ל- y יש שלושה בנים: הוצא את x מקבוצת הבנים של y (הזז את שני הבנים הנותרים למקומות המתאימים), עדכן מפתחות צמתי הדמה וסיים. (1 ( (3 (4 אם y הוא שורש העץ (ז"א אם (root(t)=y יהיה x, בצע parent(z)=null,root(t)=z וסיים. z אחיו של (5 אם ל- y ישנו אח p (מימין או משמאל) שיש לו שלושה בנים: הוצא את x מקבוצת הבנים של, y העבר בן אחד מ- p ל-, y עדכן מפתחות צמתי הדמה וסיים. יהיה p אח מימין או משמאל ל- y (ל- p יש שני בנים). יהיה z האח של x. העבר את z להיות בן נוסף של p (במקום במתאים), עדכן מפתחות צמתי הדמה, בצע x=y וחזור ל- 3). (6 (7 84
ערימה הגדרה: עץ שלם הוא עץ שבו לכל צומת יש שני בנים, וכל העלים נמצאים באותו מרחק מהשורש. לדוגמה העץ הבא הוא עץ שלם: שלם הוא עץ שמתקבל מעץ שלם על ידי הוצאה של או כמעט הגדרה: עץ יותר צמתים באופן רציף מהחלק הימני של הרמה האחרונה בעץ. לדוגמה העץ הבא הוא עץ כמעט שלם: האיברים ברמה האחרונה בעץ כמעט שלם חייבים להופיע ברציפות משמאל עץ כמעט שלם: אינו לימין, ולכן העץ הבא לפי ההגדרות הנ"ל עץ שלם הוא עץ כמעט שלם. 85
ערימה H היא מבנה נתונים שבו האיברים נמצאים בעץ כמעט שלם ובנוסף כל איבר בעץ יותר "חביב" מהבנים שלו. כאשר "חביב" = גדול, הערימה נקראת ערימת מקסימום. כאשר "חביב" = קטן, הערימה נקראת ערימת מינימום. בהמשך (אם לא נאמר אחרת) כאשר נדבר על ערימה נתכוון לערימת מקסימום. לכל איבר x בערימה יש את השדות הרגילים כמו בעץ בינארי, דהינו:.left(x), right(x),parent(x),key(x),info(x) בנוסף לערימה יש שני מצביעים: root(h) - מצביע לשורש העץ. - אם העץ אינו שלם, אזי F(H) מצביע לאיבר ברמה הלפני אחרונה בעץ, שניתן להוסיף לו בן כך שלאחר ההוספה העץ יהיה עץ כמעט שלם. אם העץ שלם, אזי F(H) מצביע לעלה השמאלי ביותר ברמה האחרונה בעץ F(H) לדוגמה: F(H) F(H) 86
F(H) האיברים בערימה לא שומרים על הסדר כמו בעץ בינארי. החוק היחיד הוא שהאבא גדול מהבנים. לדוגמה, העץ הבא מתאר ערימה: 8 6 5 1 8 1 4-35 F(H) 87
להלן עץ שמתאר ערימה: לאלגוריתם ההוספה לערימה דוגמה 8 6 5 1 8 1 4-35 F(H) נראה איך מוסיפים 7 לערימה הנ"ל. בשלב ראשון מוסיפים את האיבר כבן של F(H) כך שלאחר ההוספה העץ יהיה עץ כמעט שלם. בדוגמה שלנו, נוסיף את 7 כבן שמאלי של 8, ונקבל: 8 6 5 1 8 1 4-35 7 F(H) בשלב השני, אם יש צורך מעדכנים את.F(H) בדוגמה שלנו F(H) נשאר ללא שינוי. בשלב השלישי, מתחילים ל"בעבע" את האיבר שהוספנו כלפי מעלה על ידי החלפתו באביו (אם הוא גדול מאביו), עד שהאיבר מגיע למקום שבו הוא קטן מאביו (או שהוא בעצמו השורש), ואז האלגוריתם מסתיים. 88
לאחר צעד אחד של בעבוע, נקבל: 8 6 5 1 7 1 4-35 8 F(H) לאחר צעד נוסף של בעבוע, נקבל: 8 7 5 1 6 1 4-35 8 F(H) כעת 7 נמצא במקום המתאים והאלגוריתם מסתיים. 89
לאלגוריתם ההוצאה מערימה דוגמה כלפי מטה) (בעבוע להלן עץ שמתאר ערימה: 8 6 5 1 8 1 4-35 F(H) נראה איך מוציאים 8 מהערימה הנ"ל. בשלב הראשון מוציאים את האיבר הימני ביותר ברמה האחרונה בעץ, ומציבים אותו במקום האיבר שאותו רוצים להוציא. בדוגמה שלנו נוציא את 35 ונציב אותו במקום 8. בשלב השני מעדכנים את F(H) אם יש צורך. בדוגמה שלנו, יש צורך לעדכן את F(H) והעץ שמתקבל אחרי שני שלבים אלה נראה כך: 35 6 5 1 8 1 4 - F(H) 9
6 בשלב השלישי מבעבעים את הצומת שהצבנו (כלפי מטה או כלפי מעלה, תלוי במצב הצומת ביחס לאביו ולבניו) עד שהצומת מגיעה למקום המתאים לה בעץ והאלגוריתם מסתיים. בבעבוע כלפי מטה מחליפים את הצומת בבן הגדול שלו. בבעבוע כלפי מעלה מחליפים את הצומת באביו. בדוגמה שלנו מבעבעים את 35 כלפי מטה. אחרי צעד אחד של בעבוע מתקבל העץ הבא: 35 5 1 8 1 4 - F(H) אחרי צעד נוסף של בעבוע מתקבל העץ הבא: 6 5 35 1 8 1 4 - F(H) ואחרי צעד נוסף של בעבוע מתקבל העץ הבא, והאלגוריתם מסתיים. 91
6 5 4 1 8 1 35 - F(H) 9
לאלגוריתם ההוצאה מערימה דוגמה כלפי מעלה) (בעבוע 6 נסתכל על הערימה האחרונה, ונראה איך מוציאים את 1 מהערימה הזאת. בשלב הראשון מוציאים את 35 מהעץ ומחליפים אותו ב- 1. בשלב השני מעדכנים את F(H) אם יש צורך, בדוגמה שלנו אין צורך לעדכן את.F(H) העץ שמתקבל לאחר שני השלבים הראשונים נראה כך: 5 4 35 8 1 F(H) 6 בשלב השלישי מבעבעים את 35 (הפעם כלפי מעלה). לאחר צעד אחד של בעבוע מתקבל העץ הבא והאלגוריתם מסתיים. 5 35 4 8 1 F(H) 93
אלגוריתם הוצאת השורש מערימה.Remove(H) הנחה: H היא ערימת מקסימום שאינה ריקה. אם הערימה מכילה איבר אחד בלבד עדכן root(h)=null F(H)=NULL וסיים. יהי x העלה הימני ביותר מבין העלים שברמה העמוקה ביותר בעץ. (ניתן למצוא את x בסיבוכיות זמן (n O(log בעזרת.(F(H) (1 ( הוצא את x מהערימה והצב אותו במקום שורש הערימה. (3 עדכן את F(H) (אם יש צורך). (4 אם המפתח של x גדול מהמפתחות של הבנים שלו סיים. החלף את x בבן בעל המפתח הגדול יותר מבין הבנים של x וחזור לצעד 5). אחרת (5 94
אלגוריתם הוצאת איבר מערימה.Delete(H,z).z הנחה: H היא ערימת מקסימום שנמצא בה האיבר יהי x העלה הימני ביותר מבין העלים שברמה העמוקה ביותר בעץ. (ניתן למצוא את x בסיבוכיות זמן (n O(log בעזרת.(F(H) ( z שבערימה. הוצא את x מהערימה והצב אותו במקום האיבר (3 עדכן את F(H) (אם יש צורך). (4 אם המפתח של x של אביו סיים. גדול מהמפתחות של הבנים שלו וקטן מהמפתח (5 אם המפתח של x אינו גדול מהמפתחות של הבנים שלו בצע: (6 החלף את x בבן בעל המפתח הגדול יותר מבין הבנים שלו. אם לאחר ההחלפה המפתח של x אינו גדול מהמפתחות של הבנים שלו חזור לצעד 6.1). אחרת סיים. (6.1 אם המפתח של x גדול מהמפתח של אביו בצע: (7 החלף את x באביו. אם לאחר ההחלפה המפתח של x מהמפתח של אביו חזור לצעד 7.1). אחרת סיים. גדול (7.1 95
נסתכל על הציור הבא שמתאר ערימה: ערימה בתוך מערך שיכון 8 6 5 1 8 1 אנחנו נרצה לשכן את הערימה הזאת בתוך מערך. לצורך כך נמספר את אברי הערימה באופן הבא: האיבר ברמה 1 (דהינו השורש) של העץ יקבל מספר 1 האיברים ברמה של העץ יקבלו את המספרים,3 לפי הסדר משמאל לימן. האיברים ברמה 3 של העץ יקבלו את המספרים 4,5,6,7 לפי הסדר משמאל לימין וכן הלאה... לדוגמה עבור הערימה הנ"ל יתקבל המספור הבא: 4-35 1 8 F(H) 3 6 8 4-4 7 5 6 5 1 8 1 9 35 F(H) 96
כעת נשכן את האיברים של הערימה במערך A כאשר האיבר A[i] של המערך יהיה האיבר שמתאים לאיבר בעץ שקיבל מספר i במספור הנ"ל. בדוגמה שלנו יתקבל המערך הבא: 1 3 4 5 6 7 8 9 1 8 6 5 8 1 1 4 35 עבור המערך A נשמור שני משתנים: A גודל המערך - array-size - heap-size מספר האיברים של הערימה שמשוכנים במערך. בדוגמה שלנו: array-size=1 ו- heap-size=9 למספור הנ"ל יש את התכונה הבאה: הבן השמאלי של האיבר A[i] הוא A[i] כאשר i heap-size או NULL כאשר i > heap-size הבן הימני של האיבר A[i] הוא A[i] כאשר 1+i heap-size או NULL כאשר i+1 > heap-size i i כאשר > 1 A[ האבא של האיבר A[i] הוא ] או NULL כאשר = 1.i בהמשך נאמר בקיצור שאיבר A[i] גדול מאיבר A[j] במקום לומר שהמפתח של האיבר A[i] גדול מהמפתח של האיבר.A[j] כאשר משכנים ערימה בתוך מערך, מתקיימת התכונה הבאה שנובעת מכך שבערימה המפתח של האבא גדול מהמפתחות של שני הבנים שלו: i A[i] < A[ ] לכל i, כך ש- 1<i מתקיים: נזכיר שבהצגת אלגוריתם ההוספה לערימה, הגדרנו פעולת בעבוע של איבר כלפי מטה, כפעולה שמחליפה את האיבר באיבר הגדול יותר מבין שני בניו וחוזר חלילה, כל עוד האיבר אינו גדול משני הבנים שלו. התוכנית הבאה מבצעת בעבוע של איבר A[i] במערך כלפי מטה. 97
heapify (A, i) if ( i > heap-size ) { return } if ( i == heap-size ) { x = max ( A[i], A[i] ) } if ( i < heap-size ) { x = max ( A[i], A[i],A[i+1] ) } if ( x == A[i] ) {return } if ( x == A[i]) { swap ( A, i, i ) heapify(a,i) } if ( x == A[i+1]) { swap ( A, i, i+1 ) heapify(a,i+1) } swap (A, i, j) temp=a[i] A[i]=A[j] A[j]=temp נסמן ב- h(i) את גובה האיבר A[i] ב-.heap טענה: סיבוכיות זמן הריצה של התוכנית heapify(a,i) היא.θ(h(i)) מאחר ו- (1)h מציין את גובה הערימה, ובערימה מתקיים h=θ(logn) כאשר n מציין את מספר האיברים בערימה, (דהינו,(n=heap-size אזי מהטענה הנ"ל נובע שסיבוכיות זמן הריצה של התוכנית heapify(a,1) היא.θ(logn) 98
לאלגוריתם בנית ערימה דוגמה נסתכל על מערך A שמכיל 8 איברים בסדר כלשהו: 1 3 4 5 6 7 8 1 3 4 5 7 35 6 8 המטרה: לשנות את סדר האיברים במערך A כך שהוא יכיל ערימה. במילים אחרות, צריך לשנות את סדר האיברים במערך A כך שיתקיים כלל הערימה: i A[i] < A[ ] לכל i, כך ש- 1<i מתקיים: 1 1 הפתרון: עבור i בין 1 ל- 4 נבצע: heapify(a,i) בסדר הפוך, דהינו בהתחלה נבצע heapify(a,4) אחר כך נבצע heapify(a,3) וכן הלאה... בסוף התהליך המערך יכיל ערימה. להלן תאור מפורט של התהליך. העץ המתאים למערך הנ"ל נראה כך: 3 3 4 8 4 7 5 6 5 6 7 35 8 99
לאחר ביצוע heapify(a,4) העץ יראה כך: 1 1 3 3 4 8 4 7 5 6 8 6 7 35 5 והמערך המתאים לו נראה כך: 1 3 4 5 6 7 8 1 3 6 8 7 35 4 5 לאחר ביצוע heapify(a,3) העץ יראה כך: 1 1 3 3 6 8 4 7 5 6 8 4 7 35 5 והמערך המתאים לו נראה כך: 1 3 4 5 6 7 8 1 3 6 8 7 35 4 5 1
לאחר ביצוע heapify(a,) העץ יראה כך: 1 1 3 8 6 8 4 7 5 6 5 4 7 35 3 והמערך המתאים לו נראה כך: 1 3 4 5 6 7 8 1 8 6 5 7 35 4 3 לאחר ביצוע heapify(a,1) העץ יראה כך: 1 8 3 7 6 8 4 7 5 6 5 4 1 35 3 והמערך המתאים לו נראה כך: 1 3 4 5 6 7 8 8 7 6 5 1 35 4 3 11
בנית ערימה אלגוריתם הפסיאודו קוד של אלגוריתם בנית ערימה נראה כך: Build-Heap(A) n = length(a) heap-size = n n for i = to 1 do Heapify(A,i) done טענה: סיבוכיות זמן הריצה של התוכנית Build-Heap(A) עבור מערך קלט A בגודל n היא.θ(n) הוכחה x 1 x x= 1 = 1 x x k x= 1 + 3 + 3 k = (1 k ) 4 + 4 +... = 1 ידוע שעבור < 1 k < מתקיים: בפרט עבור = k מתקיים: 1 1 = 1 1 4 = 1 נסמן ב- n את גודל המערך A. נסמן ב- h(i) את גובה האיבר A[i] בעץ המתאים למערך A. נסמן ב- T(n) את זמן הריצה של התוכנית Build-Heap(A) עבור מערך קלט A בגודל n. כל קריאה ל- Heapify(A,i) מתבצעת בסיבוכיות זמן θ(h(i)) ולכן לוקחת לכל היותר פעולות. לכן נקבל: C h (i) i = n n T (n ) C + C1 + C h (i) i= 1 נסמן ב- h את גובה העץ המתאים למערך A. נזכיר שרמה של צומת בעץ שווה למספר הצמתים במסלול שמחבר בין הצומת לשורש העץ. 1
ברמה 1 בעץ יש צומת אחד שגובהו h ברמה בעץ ישנם צמתים שגובה כל אחד מהם הוא לכל היותר 1-h ברמה 3 בעץ ישנם צמתים שגובה כל אחד מהם הוא לכל היותר -h h-(i-1) צמתים שגובה כל אחד מהם הוא לכל היותר i 1 ברמה i בעץ ישנם... ברמה 1-h בעץ ישנם h צמתים שגובה כל אחד מהם הוא לכל היותר h 1 ברמה h בעץ ישנם לכל היותר צמתים שגובה כל אחד מהם הוא 1. i = n h (i) = i= 1 h (1) + h () + h (3)... + h (n ) לכן נקבל ש- 1 h + (h 1) + (h ) +... + h + h 1 1= = h 1 1+ h + h 3 3+... + (h ) + (h 1) + 1 h = = h 1 + + 3 3 +... + h h + h 1 h 1 + h h h 1 + + 3 3 +... = h = h+ 1 i= n h+ 1 h (i) i= 1 i= n i= n h+ 1 C h (i) = C h (i) C i= 1 i= 1 לסיכום קיבלנו ש- ולכן, ובהצבה באי השוויון הקודם נקבל: T (n ) i= n n n h+ 1 C + C1 + C h (i) C + C1 + C i= 1 עזר: טענת יהיה T עץ כמעט שלם בעל n צמתים וגובה h, אזי h 1+ log (n + 1) 13
טענת העזר: הוכחת נספור את האיברים בעץ T לפי רמות עד הרמה לפני האחרונה ברמה הראשונה יש 1 איבר ברמה השנייה יש איברים איברים ברמה השלישית יש... ברמה ה- 1-h (שהיא הרמה הלפני אחרונה) יש h איברים מאחר ולא ספרנו את האיברים ברמה האחרונה מספר האיברים הכולל בעץ n קטן ממספר האיברים ברמות 1 עד 1-h ולכן: n 1+ + +... + h = h 1 1 1 = h 1 1 n h 1 1 n + 1 h 1 log (n + 1) h 1 1+ log (n + 1) h h 1+ log (n + 1) מ.שששש.לללל העזר) (טענת T (n ) C + C1 נחזור לנוסחה האחרונה שקיבלנו ונשתמש בטענת העזר: n h+ 1 n 1+ log (n+ 1) + 1 + C C + C1 + C = = C + C 1 n + C n + C log (n+ 1) = C + C1 (n + 1) = θ (n ) T (n ) n ולכן הראנו ש-.T(n)=О(n) מאחר ונכנסים ללולאה לפחות פעמים, נקבל ש- = θ(n ) ולכן הראנו ש-.T(n)=Ω(n) לסיכום נקבל ש-.T(n)=θ(n) מ.שששש.לללל n 14
המיון בעית נתון: מערך A מטרה: סידור האיברים במערך A לפי מפתחות בסדר עולה. לדוגמא, אם נתון המערך A הבא: 1 3 4 5 6 7 8 1 3 4 5 7 35 6 8 לאחר המיון, המערך A נראה כך: 1 3 4 5 6 7 8 1 3 35 4 5 6 7 8 בעית המיון בעזרת עץ AVL פתרון הפתרון יתבצע באופן הבא, ניצור תחילה עץ AVL ונעביר אליו את כל אברי המערך אחד אחד. לאחר מכן נבצע סריקת inorder של העץ ונציב את האיברים שלו לפי סדר הסריקה לתוך המערך A. לדוגמא, אחרי צעד 1 עץ ה- AVL יראה כך: אחרי צעד עץ ה- AVL יראה כך: 1 1 3 15
אחרי צעד 3 עץ ה- AVL נראה כך: 3 1 4 אחרי צעד 4 עץ ה- AVL נראה כך: 3 1 4 5 וכן הלאה, אחרי צעד 8 עץ ה- AVL נראה כך: 4 3 6 1 7 35 5 כעת נשכן את האיברים שבעץ במערך לפי סדר.inorder אחרי הצעד הראשון המערך נראה כך: 1 3 4 5 6 7 8 1 3 4 5 7 35 6 8 8 16
אחרי הצעד השני המערך נראה כך: 1 3 4 5 6 7 8 1 3 4 5 7 35 6 8 אחרי הצעד השלישי המערך נראה כך: 1 3 4 5 6 7 8 1 3 35 5 7 35 6 8 וכן הלאה עד שלבסוף אחרי הצעד השמיני המערך נראה כך: 1 3 35 4 5 6 7 8 17
להלן, הפסיאודו קוד של אלגוריתם המיון בעזרת עץ :AVL sort(a) ----------- T=create-empty-AVL-tree() for (i=1 ; i n; i++) { insert-avl(t,a[i]) } i=1 /* i is a global variable */ inorder(t,a) הפונקציה inorder(t,a) משתמשת במשתנה גלובלי i והפסיאודו-קוד שלה הוא: inorder(t,a) ------------------ x=root(t) if (x==null) { return } inorder(t left(x),a) A[i]=x i++ inorder(t right(x),a) טענה: סיבוכיות אלגוריתם המיון בעזרת עץ היא.θ(nlogn) הוכחה: בלולאה הראשונה, כל צעד לוקח לכל היותר,c logn על סמך העובדה שסיבוכיות זמן הריצה של אלגוריתם ההוספה לעץ AVL היא.θ(logn) על הלולאה חוזרים n פעמים לכן סה"כ הלולאה הראשונה לוקחת לכל היותר c nlogn פעולות. באופן דומה לניתוח של סריקת inorder אפשר להראות שסיבוכיות זמן הריצה של פונקצית העזר inorder(t,a) היא θ(n) ולכן לוקחת לכל היותר c n 1 פעולות. לכן נקבל ש- T (n ) c n log n + c1n = θ(n log T (n ) = Ο (n log n ) n ) ומכאן נובע ש- n n להוכחת הכוון השני, n n הוספת האיבר A לעץ לוקחת לפחות log פעולות log פעולות A לעץ לוקחת לפחות + 1 הוספת האיבר... n [ n] הוספת האיבר לעץ לוקחת לפחות log פעולות. A 18
סה"כ מספר הפעולות של הלולאה הראשונה הוא לפחות ולכן, ולכן הראנו ש-.T(n)=Ω(n logn) לסיכום נקבל ש-.T(n)=θ(n logn) מ.שששש.לללל n log n T (n ) n log n = θ(n log n ) של תוכנית מוגדרת כהערכה (במונחים של θ) של מספר סיבוכיות מקום ניתוח תאי הזכרון שהתוכנית צורכת בנוסף על מבני הנתונים והמשתנים שהועברו לתוכנית כפרמטרים. לדוגמה, סיבוכיות המקום של תוכנית המיון בעזרת עץ AVL הנ"ל היא,θ(n) מאחר והיא משתמשת במבנה נוסף של עץ,AVL ועץ AVL (כמו כל עץ בינארי) ניתן לאיחסון על ידי c n תאי זכרון, מאחר ולכל איבר x בעץ מספיק לשמור את השדות key(x),info(x),left(x),right(x),parent(x) שהזכרון הנתפש על ידם הוא קבוע c שאינו תלוי ב- n. 19
בעית המיון בעזרת ערימה פתרון נציג את הפתרון בעזרת דוגמה. נניח שנתון לנו המערך A הבא: 1 3 4 5 6 7 8 1 3 4 5 7 35 6 8 בשלב הראשון, נשנה את סדר האיברים במערך כך שהוא יכיל ערימה, על ידי אלגוריתם בנית ערימה שתיארנו קודם. התוצאה שנקבל היא: 1 3 4 5 6 7 8 8 7 6 5 1 35 4 3 heap-size 1 8 כל האיברים במערך הנ"ל שיכים לערימה, ולכן עבור המערך הנ"ל מתקיים,heap-size=8 והערימה המתאימה לו נראית כך: 3 7 6 8 4 7 5 6 5 4 1 35 3 11
בשלב הבא נחליף בין [1]A לבין האיבר האחרון בערימה,A[n] 1 נקטין את heap-size ב-, 1 התוצאה נראית כך: 1 3 4 5 6 7 8 3 7 6 5 1 35 4 8 1 3 נשים לב האיבר 8 נמצא במקום המתאים לו במערך הממוין הסופי. העץ המתאים למערך הנ"ל (שמכיל 7 איברים כי (heap-size=7 נראה כך: heap-size 7 6 4 7 5 6 5 4 1 35 3 1 7 העץ אינו מכיל ערימה חוקית, בגלל האיבר 3. כדי להפוך אותו לערימה חוקית נבעבע את האיבר 3 כלפי מטה. לאחר בעבוע האיבר 3 (את הבעבוע נבצע ישירות על המערך כפי שתיארנו קודם) יתקבל העץ הבא: 3 5 6 4 7 5 6 3 4 1 35 111
המערך שמתאים לעץ הנ"ל נראה כך: 1 3 4 5 6 7 8 7 5 6 3 1 35 4 8 heap-size כעת נחזור על התהליך פעם נוספת, נחליף בין [1]A לאיבר האחרון בערימה, שעכשיו הוא A[n-1], נקטין heap-size ב- 1 והתוצאה נראית כך: 1 3 4 5 6 7 8 4 5 6 3 1 35 7 8 heap-size נשים לב שאיברים 7,8 נמצאים במקום המתאים להם במערך הממוין הסופי. העץ המתאים למערך הנ"ל (שמכיל 6 איברים כי (heap-size=6 נראה כך: 1 4 3 5 6 4 3 5 6 1 35 נבעבע את האיבר 4 כלפי מטה ונקבל את העץ הבא: 1 6 3 5 4 4 3 5 6 1 35 11
המערך שמתאים לעץ הנ"ל נראה כך: 1 3 4 5 6 7 8 6 5 4 3 1 35 7 8 heap-size נחזור על התהליך הנ"ל 5 פעמים נוספות עד שנקבל את התוצאה: 1 3 4 5 6 7 8 1 3 35 4 5 6 7 8 heap-size כעת המערך ממוין ואין צורך לחזור על התהליך פעם נוספת. הפסיאודו קוד של אלגוריתם המיון בעזרת ערימה נראה כך: heap-sort(a) n = length(a) build-heap(a) for (i=n ; i ; i--) { swap (A[1],A[i]) heap-size = heap-size - 1 heapify(a,1) } טענה: סיבוכיות זמן הריצה של אלגוריתם heap-sort(a) עבור מערך קלט A בגודל n היא.θ(n logn) הוכחה: הראנו קודם שהתוכנית build-heap(a) לוקח לכל היותר.c n הראנו גם שכל קריאה ל-( heapify(a,1 לוקחת לכל היותר (1)h 1 c. מאחר וגובה הצומת [1]A הוא לכל היותר c logn נקבל שכל קריאה ל-( heapify(a,1 לוקחת לכל היותר.c1 c logn מאחר ונכנסים ללולאה לכל היותר 1-n פעמים נקבל: T (n ) c n + c c n log n = θ(n 1 log n ) ולכן הראינו ש- T(n)=O(n logn) 113
n log n log n log להוכחת הכוון השני, הקריאה ל- heapify(a,1) כאשר גודל הערימה הוא n לוקחת לפחות פעולות. הקריאה ל- heapify(a,1) כאשר גודל הערימה הוא 1-n לוקחת לפחות פעולות.... הקריאה ל- heapify(a,1) כאשר גודל הערימה הוא לוקחת לפחות פעולות. n n log n סה"כ מספר הפעולות של הלולאה הוא לפחות ולכן, ולכן הראנו ש-.T(n)=Ω(n logn) לסיכום נקבל ש-.T(n)=θ(n logn) T (n ) מ.שששש.לללל n log n = θ(n log n ) מאחר והתוכנית heap-sort(a) לא משתמשת במבנה עזר של משתנים בלבד), סיבוכיות המקום שלה היא (1)θ. (אלא במספר קבוע 114
נתונים לדרישות מבנה התאמת הצע מבנה נתונים העונה לדרישות הבאות (כאשר n מציין את מספר האיברים במבנה הנתונים): - כאשר מבנה הנתונים ריק ניתן להוסיף לו n איברים (כפעולה אחת) בזמן.O(n) - זמן הריצה של פעולת חיפוש איבר במבנה הנתונים הוא O(n) במקרה W.C אבל על לפחות n/logn מהאיברים זמן הריצה של פעולת חיפוש הוא O(logn) - זמני הריצה של הוספה והוצאה של איברים למבני הנתונים אינם מוגבלים..1 תאר באופן מילולי כיצד מתבצעת כל אחת מהפעולות במבנה הנתונים שהצעת. (אין צורך לפרט מחדש אלגוריתמים שהוצגו בכיתה).. הצע מבנה נתונים שאיבריו הם מספרים טבעיים והוא עונה לדרישות הבאות (כאשר n מציין את מספר האיברים במבנה הנתונים). - הוספת איבר למבנה מבוצעת בזמן O(logn) - מחיקת איבר מהמבנה מבוצעת בזמן O(logn) - חיפוש איבר במבנה מבוצע בזמן O(logn) - מציאת זוג מספרים (כלשהם) במבנה x,y שמקימים x = 3y (אם קיימים כאלו) מבוצע בזמן (1)O. תאר באופן מילולי כיצד מתבצעת כל אחת מהפעולות במבנה הנתונים שהצעת. (אין צורך לפרט מחדש אלגוריתמים שהוצגו בכיתה). 3. הצע מבנה נתונים עבור קבוצה S של מספרים שלמים (עם חזרות) התומך בפעולות הבאות (כאשר n מציין את מספר האיברים השונים בקבוצה S): - insert(x) הוספת מופע של מספר x לקבוצה S (במידה והמספר x לא קיים ב- S הוא מתוסף לקבוצה) מבוצעת בזמן O(logn) - delete(x) מחיקת מופע של מספר x מהקבוצה S (במידה והמספר x מופיע רק פעם אחת בקבוצה S הוא מוצא מ- S) מבוצעת בזמן.O(logn) - multiplicity(x) מחזירה את הריבוי של x (כלומר את מספר המופעים של x ב- S) בזמן.O(logn) (1)O. בזמן S מחזירה את המספר המקסימלי ב- max_val() - (1)O. בזמן S מחזירה את הריבוי המקסימלי ב- max_mull() - תאר באופן מילולי כיצד מתבצעת כל אחת מהפעולות במבנה הנתונים שהצעת. (אין צורך לפרט מחדש אלגוריתמים שהוצגו בכיתה). 115
4. תאר מבנה נתונים התומך בפעולות הבאות בסיבוכיות הנדרשת. תאר באופן מילולי את האלגוריתמים למימוש הפעולות ונתח את זמן הריצה שלהם. ניתן להסתמך על אלגוריתמים שהוצגו בכיתה. init בהינתן רשימה לא ממוינת של N מספרים, אתחל את המבנה בזמן.O(NlogN).O(logN) למבנה בזמן x הכנס איבר חדש insert(x) (1)O. החזר ערך מינימלי/מכסימלי במבנה בזמן find_min, find_max /(1+N) החזר את הערך החציון במבנה ) את ערך ה- find_mid בגודלו אם N אי-זוגי או את הערך ה- /N בגודלו אם N זוגי) בזמן.O(1) del_max del_min, מחק ערך מינימלי/מכסימלי מהמבנה בזמן.O(logN).O(logN) מחק את הערך החציון מהמבנה בזמן del_mid.o(logn) בזמן בגודלו מצא את האיבר ה- k find(k) 5. נתונה קבוצה D של n איברים כך שכל איבר x בקבוצה מכיל את השדות הבאים: id(x) הינו מספר שמזהה את x באופן יחיד D מספר איברים שונים ב- (יתכנו. x הינו מספר שמכיל את המפתח של key(x) עם מפתח זהה). x. אינפורמציה נוספת (כלשהי) על האיבר info(x) הנח כי מספר המפתחות השונים ב- D הוא O(logn) א) הצע מבנה נתונים עבור הקבוצה D התומך בפעולות הבאות בסיבוכיות הנדרשת: O(log logn ) בזמן D לקבוצה x הוספת איבר insert(x) D מהקבוצה k מחיקת איבר כלשהו בעל מפתח delete(k) בזמן ) logn O(log O(log logn ) בזמן D בקבוצה k מציאת איבר כלשהו בעל מפתח search(k) תאר באופן מילולי את האלגוריתמים למימוש הפעולות ונתח את זמן הריצה שלהם. ניתן להסתמך על אלגוריתמים שהוצגו בכיתה. ב) הצע מבנה נתונים עבור הקבוצה D התומך בפעולות הבאות בסיבוכיות הנדרשת: O(logn ) בזמן D לקבוצה x הוספת איבר insert(x) (id) והמזהה היחיד שלו (k) בהינתן מפתח האיבר search_and_delete(k,id) חיפוש האיבר ומחיקתו מהקבוצה D בזמן ) O(logn O(log logn ) בזמן D בקבוצה k מציאת איבר כלשהו בעל מפתח search(k) תאר באופן מילולי את האלגוריתמים למימוש הפעולות ונתח זמן ריצה שלהם. ניתן להסתמך על אלגוריתמים שהוצגו בכיתה. 116
הצע מבנה נתונים עבור קבוצה S של מספרים שלמים (עם חזרות) התומך שנמצאים השונים בפעולות הבאות (כאשר n הוא חסם על מספר האיברים ב- S בו זמנית):.6 init(s) אתחל את מבנה הנתונים בזמן O(n) במקרה הגרוע. delete(x) מחיקת מופע של מספר x מהקבוצה S (במידה והמספר x מופיע רק פעם אחת בקבוצה S הוא מוצא מ- S) בזמן (1)O בממוצע. multiplicity(x) מחזירה את הריבוי של x (כלומר את מספר המופעים של x ב- S) בזמן (1)O בממוצע. Print_same_mul_as(x) מדפיסה את מפתחות כל האיברים שהריבוי שלהם שווה לריבוי של x, בזמן (1)O בממוצע + O(k) במקרה הגרוע, כאשר k מציין את מספר האיברים שהריבוי שלהם זהה לריבוי של x. - - - - תאר באופן מילולי כיצד מתבצעת כל אחת מהפעולות במבנה הנתונים שהצעת. (אין צורך לפרט מחדש אלגוריתמים שהוצגו בכיתה). 7. לכל מספר טבעי k נגדיר את bin(n,k) כיצוג המספר k כמספר בינארי באורך n. לדוגמה, bin(5,9) הנו המספר הבינארי 11. הצע/הציעי מבנה נתונים שמכיל מספרים טבעיים (ללא חזרות) ותומך בפעולות הבאות, כאשר n מיצג את אורך הייצוג הבינארי של המספרים ו- N מיצג את מספר המספרים שבמבנה: בהינתן מספר טבעי k וייצוגו הבינארי באורך n, הוספת המספר למבנה.O(max{logN,nlogn}) בזמן בהינתן מספר טבעי k חיפוש המספר במבנה בזמן.O(logN) בהינתן מספר טבעי k חיפוש המספר והוצאתו מהמבנה במידה והוא קיים בזמן.O(max{logN,n}) בהינתן אינדקס i מציאת מספר המספרים במבנה הנתונים שהביט ה- i שלהם דלוק בזמן (1)O. מציאת סה"כ מספר הביטים הדלוקים בכל המספרים במבנה הנתונים בזמן (1)O. ואינדקס i מציאת מספר בהינתן מספר טבעי k (ללא ייצוגו הבינארי) הביטים הדלוקים בעלי אינדקס קטן מ- i בייצוג הבינארי של k בזמן.O(log(max{N,n})) תאר/י באופן מילולי איך מתבצעת כל אחת מהפעולות הנ"ל. 117
להלן פונקציה למציאת האיבר ה- k בעץ -3 שבו יש בנוסף לשדות הרגילים שדה size(x) לכל צומת x שמכיל את מספר העלים שנמצאים בתת העץ של T ששורשו x. (דהינו בתת העץ T). x סיבוכיות זמן הריצה: θ(logn) find-element(t,k) /* find k-th element of a rank -3 tree T */ x=root(t) if (x==null size(x) < k) { return NULL } while true { if (first(x)=null) {return x} /* x is a leaf, return it */ if (size(first(x)) k) {x=first(x) continue } if (size(first(x)) + size(second(x)) k) { k=k-size(first(x)) x=second(x) continue } k=k-(size(first(x)) + size(second(x))) x=third(x) } 118
להלן פונקציה למציאת מספר האיברים שהמפתח שלהם קטן מ- k בעץ -3 שבו יש בנוסף לשדות הרגילים שדה size(x) לכל צומת x שמכיל את מספר העלים שנמצאים בתת העץ של T ששורשו x. (דהינו בתת העץ T). x סיבוכיות זמן הריצה: θ(logn) find-munber-of-elements(t,k) /* find the number of elements having a key less than k, of a rank -3 tree T */ x=root(t) if (x==null) return count= while true { if (first(x)=null) {return count+1} /* x is a leaf, return count +1 +1 is added for the leaf itself */ if (s(x) k) {x=first(x) continue } if (third(x)==null s3(x) k) { count=count+size(first(x)) x=second(x) continue } count=count+size(first(x))+size(second(x)) x=third(x) } 119